package tech.waterism.topo.converter;

import tech.waterism.topo.context.CalculationContext;
import tech.waterism.topo.model.*;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 模型转换器
 * 
 * <p>用于在原有的 DTO 对象和新的 core 模型对象之间进行转换
 * 
 * <p><b>注意：</b>这个类需要在 dispatch-model-service 中实现具体的转换逻辑，
 * 因为它需要依赖 service 层的 DTO 类（TopoObjectDto, FPIndexDto等）。
 * 这里只提供接口定义和部分通用方法。
 * 
 * @author waterism
 * @since 1.0.0
 */
public class ModelConverter {
    
    /**
     * 创建计算上下文
     * <p>从原有的 DTO 中提取数据，构建新的计算上下文
     * 
     * @param startTime 预报起始时间
     * @param observationStartTime 实测起始时间
     * @param modifyTime 修改时间
     * @param dispatchType 调度类型
     * @param outFlowType 出流类型
     * @return 计算上下文
     */
    public static CalculationContext createContext(
            Date startTime, 
            Date observationStartTime, 
            Date modifyTime,
            Integer dispatchType,
            Integer outFlowType) {
        
        CalculationContext context = new CalculationContext();
        context.setStartTime(startTime);
        context.setObservationStartTime(observationStartTime);
        context.setModifyTime(modifyTime);
        context.setDispatchType(dispatchType);
        context.setOutFlowType(outFlowType);
        
        return context;
    }
    
    /**
     * 复制时序数据（深拷贝）
     * 
     * @param source 源数据列表
     * @return 复制后的数据列表
     */
    public static List<TimeSeriesData> copyTimeSeriesData(List<TimeSeriesData> source) {
        if (source == null) {
            return new ArrayList<>();
        }
        
        return source.stream()
                .map(ModelConverter::copyTimeSeriesDataItem)
                .collect(Collectors.toList());
    }
    
    /**
     * 复制单个时序数据
     * 
     * @param source 源数据
     * @return 复制后的数据
     */
    private static TimeSeriesData copyTimeSeriesDataItem(TimeSeriesData source) {
        TimeSeriesData target = new TimeSeriesData();
        target.setDt(source.getDt());
        target.setQ(source.getQ());
        target.setRz(source.getRz());
        target.setQReal(source.getQReal());
        target.setQSim(source.getQSim());
        target.setQPrep(source.getQPrep());
        target.setQIn(source.getQIn());
        target.setQOut(source.getQOut());
        target.setV(source.getV());
        target.setQDvr(source.getQDvr());
        target.setQDsc(source.getQDsc());
        target.setNUsedGates(source.getNUsedGates());
        target.setFlowWay(source.getFlowWay());
        return target;
    }
    
    /**
     * 将曲线点列表按水位排序
     * 
     * @param curvePoints 曲线点列表
     * @return 排序后的列表
     */
    public static List<CurvePoint> sortCurvePointsByZ(List<CurvePoint> curvePoints) {
        if (curvePoints == null || curvePoints.isEmpty()) {
            return new ArrayList<>();
        }
        
        return curvePoints.stream()
                .sorted(Comparator.comparing(CurvePoint::getZ))
                .collect(Collectors.toList());
    }
    
    /**
     * 将曲线点列表按值排序
     * 
     * @param curvePoints 曲线点列表
     * @return 排序后的列表
     */
    public static List<CurvePoint> sortCurvePointsByValue(List<CurvePoint> curvePoints) {
        if (curvePoints == null || curvePoints.isEmpty()) {
            return new ArrayList<>();
        }
        
        return curvePoints.stream()
                .sorted(Comparator.comparing(CurvePoint::getValue))
                .collect(Collectors.toList());
    }
}

